Bellman_Ford算法求最短路径

/*bellman_ford算法*/
#include <iostream>
#include <fstream>
using namespace std;

#define SIZE 100
#define INL 1000000

int graph[SIZE][SIZE];
int n;
int t[SIZE];
int d[SIZE];
fstream fin;

bool bellman_ford(int s);
int main()
{
    fin.open("1004.txt",ios::in);
    int m;
    fin>>n>>m;
    int i,j;
    
    //邻接数据 
    for(i=0;i<n;i++)
      for(j=0;j<n;j++)
        graph[i][j]=INL;
    
    for(i=0;i<m;i++)
    {
        int x,y;
        fin>>x>>y;
        fin>>graph[x][y];
    }
    
   if(!bellman_ford(0))
      cout<<"can't find the best way!"<<endl;
    else
    {
        bellman_ford(0);
        for(int i=0;i<n;i++)
          cout<<d[i]<<" ";
        cout<<endl;
    }        
    system("pause");
    return 0;
} 

bool bellman_ford(int s)
{
    //初始化程序
     for(int i=0;i<n;i++)
     {
         d[i]=INL;
         t[i]=-1;
     }
     
     d[s]=0;
     
     for(int i=0;i<n-1;i++)
     {
         for(int j=0;j<n;j++)
           for(int k=0;k<n;k++)
           {
               if(graph[j][k]<INL)
               {
                   if(d[k]>d[j]+graph[j][k])
                     {
                         d[k]=d[j]+graph[j][k];
                         t[k]=j;
                     }    
               }
           }
     }
        
     for(int i=0;i<n;i++)
       for(int j=0;j<n;j++)
       {
           if(graph[i][j]<INL)
           {
               d[j]>d[i]+graph[i][j];
                return false;
           }
       }
     return true;       
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Floyd算法是一种经典的动态规划算法,用于解决有向图或者有权图中多源点的最短路径问题。它的时间复杂度为O(n^3),其中n是图中节点的个数。 Floyd算法的基本思想是:对于图中的任意两个节点,如果它们之间存在一条边,则它们之间的最短路径就是这条边的权重。否则,它们之间的最短路径就是通过中间节点的最短路径。因此,我们可以使用动态规划的思想来解任意两个节点之间的最短路径。 具体来说,我们可以定义一个二维数组dist,其中dist[i][j]表示节点i到节点j的最短路径。然后,我们可以使用三重循环来更新数组dist。每次循环中,我们枚举中间节点k,如果从节点i到节点j经过中间节点k的路径比当前的最短路径,则更新dist[i][j]的值。 下面是Floyd算法的伪代码: ``` for k from 1 to n: for i from 1 to n: for j from 1 to n: if dist[i][j] > dist[i][k] + dist[k][j]: dist[i][j] = dist[i][k] + dist[k][j] ``` 其中,dist[i][j]表示节点i到节点j的最短路径。在每一次循环中,我们枚举中间节点k,如果从节点i到节点j经过中间节点k的路径比当前的最短路径,则更新dist[i][j]的值。最终,dist数组中存储的就是任意两个节点之间的最短路径。 需要注意的是,Floyd算法只适用于稠密图,即边的数量相对于节点数目比较大的图。对于稀疏图,我们通常使用Dijkstra算法或者Bellman-Ford算法最短路径问题。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值